考虑以下递归模板:

\begin{lstlisting}[style=styleCXX]
template<typename T, typename U>
struct Doublify {
};

template<int N>
struct Trouble {
	using LongType = Doublify<typename Trouble<N-1>::LongType,
	typename Trouble<N-1>::LongType>;
};

template<>
struct Trouble<0> {
	using LongType = double;
};

Trouble<10>::LongType ouch;
\end{lstlisting}

使用Trouble<10>::LongType不仅触发了Trouble<9>， Trouble<8>，…，Trouble<0>的递归实例化，但其复杂性在Doublify的实例化处。表23.1说明了扩展增长的速度。

\begin{center}
\begin{table}[H]
	\begin{tabular}{|l|l|}
		\hline
		\textbf{类型别名}                                  & \textbf{基本类型}                                                                                                                                                                                                                                                                                                                                                                   \\ \hline
		Trouble\textless{}0\textgreater{}::LongType & double                                                                                                                                                                                                                                                                                                                                                                              \\ \hline
		Trouble\textless{}1\textgreater{}::LongType & Doublify\textless{}double,double\textgreater{}                                                                                                                                                                                                                                                                                                                                      \\ \hline
		Trouble\textless{}2\textgreater{}::LongType & \begin{tabular}[c]{@{}l@{}}Doublify\textless{}Doublify\textless{}double,double\textgreater{},\\          Doublify\textless{}double,double\textgreater{}\textgreater{}\end{tabular}                                                                                                                                                                                                  \\ \hline
		Trouble\textless{}3\textgreater{}::LongType & \begin{tabular}[c]{@{}l@{}}Doublify\textless{}Doublify\textless{}Doublify\textless{}double,double\textgreater{},\\                   Doublify\textless{}double,double\textgreater{}\textgreater{},\\         \textless{}Doublify\textless{}double,double\textgreater{},\\                   Doublify\textless{}double,double\textgreater{}\textgreater{}\textgreater{}\end{tabular} \\ \hline
	\end{tabular}
\end{table}

表23.1. Trouble<N>::LongType实例化的增长
\end{center}


从表23.1可以看出，表达式Trouble<N>::LongType的类型描述的复杂性会随着N的增加呈指数增长。通常，这种情况对C++编译器的压力，甚至比不涉及递归模板实参的递归实例化更大。这里的问题是，编译器为类型保留了损坏名称。这个混乱的名称以某种方式编码了模板特化，早期的C++实现使用的编码大致与模板标识的长度成比例。这些编译器为Trouble<10>::LongType使用了超过10,000个字符的内存。

较新的C++实现考虑到，嵌套模板标识在现代C++程序中相当常见，并使用巧妙的压缩技术来大幅减少名称编码的增长(例如，Trouble<10>::LongType需要几百个字符)。因为没有为模板实例生成低层代码，这些编译器还会避免在不需要的情况下生成混乱的名称。尽管如此，在其他条件都相同的情况下，以模板参数不需要递归嵌套的方式组织递归实例化可能是更好的方法。

















